{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 3961,
     "status": "ok",
     "timestamp": 1685488776776,
     "user": {
      "displayName": "Sokratis An",
      "userId": "06375667078137359429"
     },
     "user_tz": -120
    },
    "id": "_Evzz1__5oEu",
    "outputId": "133898c6-b95d-4ecd-c7f8-d1aced813c18"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "import time\n",
    "import torch\n",
    "import random\n",
    "import scipy.io\n",
    "import numpy as np\n",
    "from pyDOE import lhs\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "from torch.optim import lr_scheduler\n",
    "from collections import OrderedDict\n",
    "\n",
    "mpl.rcParams.update(mpl.rcParamsDefault)\n",
    "np.set_printoptions(threshold=sys.maxsize)\n",
    "plt.rcParams['figure.max_open_warning'] = 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Global functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 7,
     "status": "ok",
     "timestamp": 1685488781959,
     "user": {
      "displayName": "Sokratis An",
      "userId": "06375667078137359429"
     },
     "user_tz": -120
    },
    "id": "CaIRR9De5oEx",
    "outputId": "58f4a290-8271-43b4-8702-7581d1e98620"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda available\n"
     ]
    }
   ],
   "source": [
    "if torch.cuda.is_available():\n",
    "    \"\"\" Cuda support \"\"\"\n",
    "    print('cuda available')\n",
    "    device = torch.device('cuda')\n",
    "else:\n",
    "    print('cuda not avail')\n",
    "    device = torch.device('cpu')\n",
    "\n",
    "def seed_torch(seed):\n",
    "    \"\"\" Seed initialization \"\"\"\n",
    "    random.seed(seed)\n",
    "    np.random.seed(seed)\n",
    "    torch.manual_seed(seed)\n",
    "    torch.cuda.manual_seed(seed)\n",
    "seed_torch(2341)\n",
    "torch.cuda.empty_cache()\n",
    "\n",
    "def tonp(tensor):\n",
    "    \"\"\" Torch to Numpy \"\"\"\n",
    "    if isinstance(tensor, torch.Tensor):\n",
    "        return tensor.detach().cpu().numpy()\n",
    "    elif isinstance(tensor, np.ndarray):\n",
    "        return tensor\n",
    "    else:\n",
    "        raise TypeError('Unknown type of input, expected torch.Tensor or '\\\n",
    "            'np.ndarray, but got {}'.format(type(input)))\n",
    "\n",
    "def grad(u, x):\n",
    "    \"\"\" Get grad \"\"\"\n",
    "    gradient = torch.autograd.grad(\n",
    "        u, x,\n",
    "        grad_outputs=torch.ones_like(u),\n",
    "        retain_graph=True,\n",
    "        create_graph=True\n",
    "    )[0]\n",
    "    return gradient"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initializations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "file_path = './'\n",
    "file_name = 'losses.txt'\n",
    "\n",
    "data = scipy.io.loadmat(file_path + 'AC.mat')\n",
    "Exact = data['uu']\n",
    "Exact0 = np.real(Exact)\n",
    "t0 = data['tt'].flatten()[:,None]\n",
    "x0 = data['x'].flatten()[:,None]\n",
    "lbc = torch.tensor([x0.min(), t0.min()]).to(torch.float32).to(device)\n",
    "ubc = torch.tensor([x0.max(), t0.max()]).to(torch.float32).to(device)\n",
    "\n",
    "xdim, tdim = 4.0, 1.0\n",
    "\n",
    "nx, nt = (1001, 1001)\n",
    "x = np.linspace(-1, 1, nx)\n",
    "t = np.linspace(-1, 1, nt)\n",
    "x0, t0 = np.meshgrid(x, t)\n",
    "Exact0 = np.sin(xdim*np.pi*x0)*np.sin(tdim*np.pi*t0)\n",
    "Exact0 = Exact0.T\n",
    "x0, t0 = x[:,None], t[:,None]\n",
    "lbc = torch.tensor([x0.min(), t0.min()]).to(torch.float32).to(device)\n",
    "ubc = torch.tensor([x0.max(), t0.max()]).to(torch.float32).to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "hgsAoNRk5oEz"
   },
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "class DNN(torch.nn.Module):\n",
    "    \"\"\" DNN Class \"\"\"\n",
    "    \n",
    "    def __init__(self, layers):\n",
    "        super(DNN, self).__init__()\n",
    "        self.depth = len(layers) - 1\n",
    "        self.activation = torch.nn.Tanh\n",
    "        \n",
    "        # Layers\n",
    "        layer_list = list()\n",
    "        for i in range(self.depth - 1):\n",
    "            w_layer = torch.nn.Linear(layers[i], layers[i+1], bias=True)\n",
    "            torch.nn.init.xavier_normal_(w_layer.weight)\n",
    "            layer_list.append(('layer_%d' % i, w_layer))\n",
    "            layer_list.append(('activation_%d' % i, self.activation()))\n",
    "\n",
    "        w_layer = torch.nn.Linear(layers[-2], layers[-1], bias=True)\n",
    "        torch.nn.init.xavier_normal_(w_layer.weight)\n",
    "        layer_list.append(('layer_%d' % (self.depth - 1), w_layer))\n",
    "        layerDict = OrderedDict(layer_list)\n",
    "        # Deploy layers\n",
    "        self.layers = torch.nn.Sequential(layerDict)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        out = self.layers(x)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PINN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "u4PChpa15oEz"
   },
   "outputs": [],
   "source": [
    "class PINN():\n",
    "    \"\"\" PINN Class \"\"\"\n",
    "    \n",
    "    def __init__(self, X_u, u, X_r, lb, ub, dimx, dimt, savept=None):\n",
    "        \n",
    "        # Initialization\n",
    "        self.rba = 1  # RBA weights\n",
    "        self.sa = 0   # SA weights\n",
    "        self.iter = 0\n",
    "        self.exec_time = 0\n",
    "        self.print_step = 100\n",
    "        self.savept = savept\n",
    "        self.dimx, self.dimt = dimx, dimt\n",
    "        self.dimx_, self.dimt_ = nx, nt  # solution dim\n",
    "        self.first_opt = 20000\n",
    "        self.freeze = self.first_opt\n",
    "        self.it, self.l2, self.linf = [], [], []\n",
    "        self.loss, self.losses = None, []\n",
    "        self.opt = 1\n",
    "\n",
    "        # Intermediate results\n",
    "        self.Exact = Exact0\n",
    "        X, T = np.meshgrid(x0, t0)\n",
    "        X_star = np.hstack((X.flatten()[:,None], T.flatten()[:,None]))\n",
    "        self.xx = torch.tensor(X_star[:, 0:1]).float().to(device)\n",
    "        self.tt = torch.tensor(X_star[:, 1:2]).float().to(device)\n",
    "        \n",
    "        # Data\n",
    "        self.x_u = torch.tensor(X_u[:, 0:1], requires_grad=True).float().to(device)\n",
    "        self.t_u = torch.tensor(X_u[:, 1:2], requires_grad=True).float().to(device)\n",
    "        self.x_r = torch.tensor(X_r[:, 0:1], requires_grad=True).float().to(device)\n",
    "        self.t_r = torch.tensor(X_r[:, 1:2], requires_grad=True).float().to(device)\n",
    "        self.u = torch.tensor(u).float().to(device)\n",
    "        self.ub = self.u[self.dimx:]\n",
    "        self.u = self.u[:self.dimx]\n",
    "        self.N_r = tonp(self.x_r).size\n",
    "        self.N_u = tonp(self.u).size\n",
    "        self.dnn = DNN(layers).to(device)\n",
    "        \n",
    "        # RBA initialization\n",
    "        if self.rba == 1:\n",
    "            self.rsum = 0\n",
    "            self.eta = 0.001\n",
    "            self.gamma = 0.999\n",
    "            self.init = 1  # initialization mode (1 or 2)\n",
    "            \n",
    "        # SA weights initialization\n",
    "        if self.sa == 1:\n",
    "            self.lamr = torch.rand(self.N_r, 1, requires_grad=True).float().to(device)*1\n",
    "            self.lamu = torch.rand(self.N_u, 1, requires_grad=True).float().to(device)*1\n",
    "            self.lamr = torch.nn.Parameter(self.lamr)\n",
    "            self.lamu = torch.nn.Parameter(self.lamu)\n",
    "            # Optimizer2 (SA weights)\n",
    "            self.optimizer2 = torch.optim.Adam([self.lamr] + [self.lamu], lr=0.005, maximize=True)\n",
    "            \n",
    "        # Optimizer (1st ord)\n",
    "        self.optimizer = torch.optim.Adam(self.dnn.parameters(), lr=1e-3, betas=(0.9, 0.999))\n",
    "        self.scheduler = lr_scheduler.ExponentialLR(self.optimizer, gamma=0.9, verbose=True)\n",
    "        self.step_size = 5000\n",
    "\n",
    "    def net_u(self, x, t):\n",
    "        \"\"\" Get the velocities \"\"\"\n",
    "        \n",
    "        u = self.dnn(torch.cat([x, t], dim=1))\n",
    "        return u\n",
    "\n",
    "    def net_r(self, x, t):\n",
    "        \"\"\" Get the residuals \"\"\"\n",
    "        \n",
    "        u = self.net_u(x, t)\n",
    "        u_t = grad(u, t)\n",
    "        u_tt = grad(u_t, t)\n",
    "        u_x = grad(u, x)\n",
    "        u_xx = grad(u_x, x)\n",
    "        a1 = xdim\n",
    "        a2 = tdim\n",
    "        ksq = 1.0\n",
    "        force = - (a1*np.pi)**2*torch.sin(a1*np.pi*x)*torch.sin(a2*np.pi*t) - \\\n",
    "                    (a2*np.pi)**2*torch.sin(a1*np.pi*x)*torch.sin(a2*np.pi*t) + \\\n",
    "                    ksq*torch.sin(a1*np.pi*x)*torch.sin(a2*np.pi*t)\n",
    "        f = u_xx + u_tt + ksq*u - force\n",
    "        return f, u_x\n",
    "\n",
    "    def loss_func(self):\n",
    "        \"\"\" Loss function \"\"\"\n",
    "        \n",
    "        self.optimizer.zero_grad()\n",
    "        if self.sa == 1:\n",
    "            self.optimizer2.zero_grad()\n",
    "\n",
    "        # Predictions\n",
    "        self.u_pred = self.net_u(self.x_u, self.t_u)\n",
    "        self.r_pred, u_x_pred = self.net_r(self.x_r, self.t_r)\n",
    "\n",
    "        if self.rba == True:\n",
    "            eta = 1 if self.init == 2 and self.iter == 0 else self.eta\n",
    "            r_norm = eta*torch.abs(self.r_pred)/torch.max(torch.abs(self.r_pred))\n",
    "            self.rsum = (self.rsum*self.gamma + r_norm).detach()\n",
    "            loss_r = torch.mean((self.rsum*self.r_pred)**2)\n",
    "            loss_u = torch.mean((self.u_pred - self.u)**2)\n",
    "            \n",
    "        elif self.sa == True and self.iter < self.freeze:\n",
    "            loss_r = torch.mean((self.lamr*self.r_pred)**2)\n",
    "            loss_u = torch.mean((self.lamu*(self.u_pred - self.u))**2)\n",
    "\n",
    "        else:\n",
    "            loss_r = torch.mean(self.r_pred**2)\n",
    "            loss_u = torch.mean((self.u_pred - self.u)**2)\n",
    "\n",
    "        # Loss calculation\n",
    "        self.loss = loss_r + loss_u\n",
    "        self.loss.backward()\n",
    "        self.iter += 1\n",
    "\n",
    "        if self.iter % self.print_step == 0:\n",
    "            \n",
    "            with torch.no_grad():\n",
    "                # Grid prediction (for relative L2)\n",
    "                res = self.net_u(self.xx, self.tt)\n",
    "                sol = tonp(res)\n",
    "                sol = np.reshape(sol, (self.dimt_, self.dimx_)).T\n",
    "\n",
    "                # L2 calculation\n",
    "                l2_rel = np.linalg.norm(self.Exact.flatten() - sol.flatten(), 2) / np.linalg.norm(self.Exact.flatten(), 2)\n",
    "                l_inf = np.linalg.norm(self.Exact.flatten() - sol.flatten(), np.inf) / np.linalg.norm(self.Exact.flatten(), np.inf)\n",
    "                print('Iter %d, Loss: %.3e, Rel_L2: %.3e, L_inf: %.3e, t/iter: %.1e' % \n",
    "                     (self.iter, self.loss.item(), l2_rel, l_inf, self.exec_time))\n",
    "                print()\n",
    "                \n",
    "                self.it.append(self.iter)\n",
    "                self.l2.append(l2_rel)\n",
    "                self.linf.append(l_inf)\n",
    "            \n",
    "        # Optimizer properties\n",
    "        if self.opt == 1:\n",
    "            self.optimizer.step()\n",
    "            if self.sa == True:\n",
    "                self.optimizer2.step()\n",
    "        elif self.opt == 2:\n",
    "            return self.loss\n",
    "                \n",
    "    def train(self):\n",
    "        \"\"\" Train model \"\"\"\n",
    "        \n",
    "        self.dnn.train()\n",
    "        for epoch in range(self.first_opt):\n",
    "            start_time = time.time()\n",
    "            self.loss_func()\n",
    "            end_time = time.time()\n",
    "            self.exec_time = end_time - start_time\n",
    "            if (epoch+1) % self.step_size == 0:\n",
    "                self.scheduler.step()\n",
    "                \n",
    "        self.opt = 2\n",
    "        print('LBFGS switch')\n",
    "\n",
    "        self.optimizer = torch.optim.LBFGS(\n",
    "            self.dnn.parameters(),\n",
    "            lr=0.8,\n",
    "            max_iter=100,\n",
    "            # max_eval=50000,\n",
    "            # history_size=50,\n",
    "            tolerance_grad=1.e-5,\n",
    "            tolerance_change=1.e-9,\n",
    "            # line_search_fn=\"strong_wolfe\"\n",
    "        )\n",
    "        for epoch in range(20):\n",
    "            self.optimizer.step(self.loss_func)\n",
    "\n",
    "        # Write data\n",
    "        a = np.array(self.it)\n",
    "        b = np.array(self.l2)\n",
    "        c = np.array(self.linf)\n",
    "        # Stack them into a 2D array.\n",
    "        d = np.column_stack((a, b, c))\n",
    "        file = open(file_path + file_name, \"w+\")\n",
    "        file.close()\n",
    "        file = open(file_path + file_name, \"w+\")\n",
    "        file.close()\n",
    "        # Write to a txt file\n",
    "        np.savetxt('losses.txt', d, fmt='%.10f %.10f %.10f')\n",
    "\n",
    "        if self.savept != None:\n",
    "            torch.save(self.dnn.state_dict(), str(self.savept)+\".pt\")\n",
    "    \n",
    "    def predict(self, X):\n",
    "        x = torch.tensor(X[:, 0:1]).float().to(device)\n",
    "        t = torch.tensor(X[:, 1:2]).float().to(device)\n",
    "        self.dnn.eval()\n",
    "        u = self.net_u(x, t)\n",
    "        u = tonp(u)\n",
    "        return u"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 912
    },
    "executionInfo": {
     "elapsed": 44,
     "status": "ok",
     "timestamp": 1685488787332,
     "user": {
      "displayName": "Sokratis An",
      "userId": "06375667078137359429"
     },
     "user_tz": -120
    },
    "id": "npcOQYDw5oE0",
    "outputId": "9642bf84-2e92-4f9b-da42-8c2c98212b63",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_r shape: (25600, 2)\n",
      "X_u shape: (200, 2)\n",
      "u shape: (200, 1)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Collocation points\n",
    "dimx = nx\n",
    "dimt = nt\n",
    "N_u = 50\n",
    "N_r = 25600\n",
    "hidden = 128\n",
    "layers = [2] + [hidden]*6 + [1]\n",
    "\n",
    "# Definition\n",
    "Exact = Exact0.T\n",
    "tm = np.linspace(t0.min(), t0.max(), dimt)[:, None]\n",
    "xm = np.linspace(x0.min(), x0.max(), dimx)[:, None]\n",
    "X, T = np.meshgrid(xm, tm)\n",
    "\n",
    "# Doman bounds\n",
    "lb = tonp(lbc)\n",
    "ub = tonp(ubc)\n",
    "xx1 = np.hstack((x0*0-1, t0))\n",
    "uu1 = np.zeros_like(x0)\n",
    "\n",
    "# Top/bot boundaries\n",
    "xx2 = np.hstack((x0, t0*0+1))\n",
    "xx3 = np.hstack((x0, t0*0-1))\n",
    "xx4 = np.hstack((x0*0+1, t0))\n",
    "uu2 = uu1\n",
    "uu3 = uu1\n",
    "uu4 = uu1\n",
    "\n",
    "# Random choice\n",
    "idx0 = np.random.choice(dimt, N_u, replace=False)\n",
    "idx = np.random.choice(dimt, N_u, replace=False)\n",
    "idx2 = np.random.choice(dimt, N_u, replace=False)\n",
    "idx3 = np.random.choice(dimt, N_u, replace=False)\n",
    "                 \n",
    "u_train = np.vstack([uu1[idx0, :], uu2[idx, :], uu3[idx2, :], uu4[idx3, :]])\n",
    "X_u_train = np.vstack([xx1[idx0, :], xx2[idx, :], xx3[idx2, :], xx4[idx3, :]])\n",
    "\n",
    "# Collocation points\n",
    "X_r_train = lb + (ub-lb)*lhs(2, N_r)\n",
    "\n",
    "print('X_r shape:', X_r_train.shape)\n",
    "print('X_u shape:', X_u_train.shape)\n",
    "print('u shape:', u_train.shape)\n",
    "            \n",
    "plt.figure(1)\n",
    "plt.title('Collocation points')\n",
    "plt.scatter(X_r_train[:, 1], X_r_train[:, 0], s=0.5)\n",
    "plt.scatter(X_u_train[:, 1], X_u_train[:, 0], s=0.5, c='k')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 39,
     "status": "ok",
     "timestamp": 1685488787332,
     "user": {
      "displayName": "Sokratis An",
      "userId": "06375667078137359429"
     },
     "user_tz": -120
    },
    "id": "tdlu03ND5oE1",
    "outputId": "a2f8315f-aa62-449d-d28c-296096800f60"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adjusting learning rate of group 0 to 1.0000e-03.\n"
     ]
    }
   ],
   "source": [
    "model = PINN(X_u_train, u_train, X_r_train, lb, ub, dimx, dimt=N_u, savept='weights')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iter 100, Loss: 3.539e+01, Rel_L2: 9.966e-01, L_inf: 9.966e-01, t/iter: 2.6e-02\n",
      "\n",
      "Iter 200, Loss: 6.359e+01, Rel_L2: 2.439e+00, L_inf: 2.439e+00, t/iter: 2.4e-02\n",
      "\n",
      "Iter 300, Loss: 2.632e+01, Rel_L2: 2.657e+00, L_inf: 2.657e+00, t/iter: 2.4e-02\n",
      "\n",
      "Iter 400, Loss: 2.309e+00, Rel_L2: 2.074e+00, L_inf: 2.074e+00, t/iter: 2.5e-02\n",
      "\n",
      "Iter 500, Loss: 2.039e-01, Rel_L2: 8.267e-01, L_inf: 8.267e-01, t/iter: 2.4e-02\n",
      "\n",
      "Iter 600, Loss: 7.326e-02, Rel_L2: 1.624e-01, L_inf: 1.624e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 700, Loss: 9.518e-02, Rel_L2: 1.418e-01, L_inf: 1.418e-01, t/iter: 2.4e-02\n",
      "\n",
      "Iter 800, Loss: 1.452e+00, Rel_L2: 1.738e-01, L_inf: 1.738e-01, t/iter: 2.4e-02\n",
      "\n",
      "Iter 900, Loss: 4.939e-02, Rel_L2: 1.093e-01, L_inf: 1.093e-01, t/iter: 2.4e-02\n",
      "\n",
      "Iter 1000, Loss: 1.753e-01, Rel_L2: 1.073e-01, L_inf: 1.073e-01, t/iter: 2.4e-02\n",
      "\n",
      "Iter 1100, Loss: 2.426e-01, Rel_L2: 1.093e-01, L_inf: 1.093e-01, t/iter: 2.4e-02\n",
      "\n",
      "Iter 1200, Loss: 4.247e-02, Rel_L2: 9.134e-02, L_inf: 9.134e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 1300, Loss: 3.667e-02, Rel_L2: 8.735e-02, L_inf: 8.735e-02, t/iter: 2.4e-02\n",
      "\n",
      "Iter 1400, Loss: 3.235e-02, Rel_L2: 8.435e-02, L_inf: 8.435e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 1500, Loss: 2.889e-02, Rel_L2: 8.161e-02, L_inf: 8.161e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 1600, Loss: 2.603e-02, Rel_L2: 7.904e-02, L_inf: 7.904e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 1700, Loss: 2.358e-02, Rel_L2: 7.677e-02, L_inf: 7.677e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 1800, Loss: 5.147e+00, Rel_L2: 2.228e-01, L_inf: 2.228e-01, t/iter: 2.4e-02\n",
      "\n",
      "Iter 1900, Loss: 1.922e+01, Rel_L2: 3.711e-01, L_inf: 3.711e-01, t/iter: 2.4e-02\n",
      "\n",
      "Iter 2000, Loss: 4.571e+00, Rel_L2: 2.199e-01, L_inf: 2.199e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2100, Loss: 3.457e-02, Rel_L2: 6.652e-02, L_inf: 6.652e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2200, Loss: 2.776e-02, Rel_L2: 6.599e-02, L_inf: 6.599e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2300, Loss: 2.383e-02, Rel_L2: 6.547e-02, L_inf: 6.547e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2400, Loss: 2.097e-02, Rel_L2: 6.453e-02, L_inf: 6.453e-02, t/iter: 2.4e-02\n",
      "\n",
      "Iter 2500, Loss: 1.874e-02, Rel_L2: 6.367e-02, L_inf: 6.367e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2600, Loss: 1.691e-02, Rel_L2: 6.294e-02, L_inf: 6.294e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2700, Loss: 1.531e-02, Rel_L2: 6.224e-02, L_inf: 6.224e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2800, Loss: 1.827e+00, Rel_L2: 1.574e-01, L_inf: 1.574e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2900, Loss: 2.986e-01, Rel_L2: 8.374e-02, L_inf: 8.374e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3000, Loss: 1.253e+00, Rel_L2: 9.725e-02, L_inf: 9.725e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3100, Loss: 4.179e-02, Rel_L2: 5.224e-02, L_inf: 5.224e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3200, Loss: 1.406e-01, Rel_L2: 6.462e-02, L_inf: 6.462e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3300, Loss: 4.663e+00, Rel_L2: 1.436e-01, L_inf: 1.436e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3400, Loss: 6.053e-02, Rel_L2: 4.920e-02, L_inf: 4.920e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3500, Loss: 2.082e-02, Rel_L2: 4.923e-02, L_inf: 4.923e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3600, Loss: 1.762e-02, Rel_L2: 5.034e-02, L_inf: 5.034e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3700, Loss: 1.556e-02, Rel_L2: 4.997e-02, L_inf: 4.997e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3800, Loss: 1.397e-02, Rel_L2: 4.947e-02, L_inf: 4.947e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3900, Loss: 1.261e-02, Rel_L2: 4.909e-02, L_inf: 4.909e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4000, Loss: 1.141e-02, Rel_L2: 4.874e-02, L_inf: 4.874e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4100, Loss: 1.035e-02, Rel_L2: 4.831e-02, L_inf: 4.831e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4200, Loss: 9.411e-03, Rel_L2: 4.775e-02, L_inf: 4.775e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4300, Loss: 8.580e-03, Rel_L2: 4.703e-02, L_inf: 4.703e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4400, Loss: 7.841e-03, Rel_L2: 4.615e-02, L_inf: 4.615e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4500, Loss: 7.180e-03, Rel_L2: 4.513e-02, L_inf: 4.513e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4600, Loss: 6.587e-03, Rel_L2: 4.398e-02, L_inf: 4.398e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4700, Loss: 6.055e-03, Rel_L2: 4.271e-02, L_inf: 4.271e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4800, Loss: 5.575e-03, Rel_L2: 4.136e-02, L_inf: 4.136e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4900, Loss: 5.144e-03, Rel_L2: 3.994e-02, L_inf: 3.994e-02, t/iter: 2.4e-02\n",
      "\n",
      "Iter 5000, Loss: 4.755e-03, Rel_L2: 3.847e-02, L_inf: 3.847e-02, t/iter: 2.5e-02\n",
      "\n",
      "Adjusting learning rate of group 0 to 9.0000e-04.\n",
      "Iter 5100, Loss: 4.443e-03, Rel_L2: 3.712e-02, L_inf: 3.712e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5200, Loss: 4.157e-03, Rel_L2: 3.577e-02, L_inf: 3.577e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5300, Loss: 3.893e-03, Rel_L2: 3.444e-02, L_inf: 3.444e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5400, Loss: 9.953e-02, Rel_L2: 3.982e-02, L_inf: 3.982e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5500, Loss: 2.012e-02, Rel_L2: 3.880e-02, L_inf: 3.880e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5600, Loss: 6.282e-03, Rel_L2: 3.055e-02, L_inf: 3.055e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5700, Loss: 4.889e-03, Rel_L2: 3.213e-02, L_inf: 3.213e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5800, Loss: 2.229e-02, Rel_L2: 3.313e-02, L_inf: 3.313e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5900, Loss: 2.502e-02, Rel_L2: 3.876e-02, L_inf: 3.876e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6000, Loss: 5.685e-03, Rel_L2: 3.017e-02, L_inf: 3.017e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6100, Loss: 4.724e-03, Rel_L2: 3.126e-02, L_inf: 3.126e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6200, Loss: 3.183e+00, Rel_L2: 1.449e-01, L_inf: 1.449e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6300, Loss: 2.821e-01, Rel_L2: 5.157e-02, L_inf: 5.157e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6400, Loss: 6.044e-02, Rel_L2: 3.469e-02, L_inf: 3.469e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6500, Loss: 1.414e+00, Rel_L2: 8.713e-02, L_inf: 8.713e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6600, Loss: 4.211e-02, Rel_L2: 3.065e-02, L_inf: 3.065e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6700, Loss: 7.894e-03, Rel_L2: 3.000e-02, L_inf: 3.000e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6800, Loss: 6.542e-03, Rel_L2: 3.015e-02, L_inf: 3.015e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6900, Loss: 5.722e-03, Rel_L2: 2.939e-02, L_inf: 2.939e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7000, Loss: 5.112e-03, Rel_L2: 2.842e-02, L_inf: 2.842e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7100, Loss: 4.625e-03, Rel_L2: 2.747e-02, L_inf: 2.747e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7200, Loss: 4.225e-03, Rel_L2: 2.661e-02, L_inf: 2.661e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7300, Loss: 3.888e-03, Rel_L2: 2.581e-02, L_inf: 2.581e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7400, Loss: 3.599e-03, Rel_L2: 2.507e-02, L_inf: 2.507e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7500, Loss: 3.349e-03, Rel_L2: 2.438e-02, L_inf: 2.438e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7600, Loss: 3.131e-03, Rel_L2: 2.373e-02, L_inf: 2.373e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7700, Loss: 2.939e-03, Rel_L2: 2.313e-02, L_inf: 2.313e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7800, Loss: 2.771e-03, Rel_L2: 2.255e-02, L_inf: 2.255e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7900, Loss: 2.620e-03, Rel_L2: 2.198e-02, L_inf: 2.198e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8000, Loss: 1.080e+00, Rel_L2: 1.314e-01, L_inf: 1.314e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8100, Loss: 1.499e+00, Rel_L2: 1.946e-01, L_inf: 1.946e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8200, Loss: 4.424e-01, Rel_L2: 6.274e-02, L_inf: 6.274e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8300, Loss: 1.551e+00, Rel_L2: 8.925e-02, L_inf: 8.925e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8400, Loss: 1.371e+00, Rel_L2: 1.249e-01, L_inf: 1.249e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8500, Loss: 2.488e+00, Rel_L2: 9.318e-02, L_inf: 9.318e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8600, Loss: 1.251e+00, Rel_L2: 6.280e-02, L_inf: 6.280e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8700, Loss: 2.460e-01, Rel_L2: 3.648e-02, L_inf: 3.648e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8800, Loss: 1.459e+00, Rel_L2: 6.203e-02, L_inf: 6.203e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8900, Loss: 1.447e+00, Rel_L2: 6.112e-02, L_inf: 6.112e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9000, Loss: 1.126e+00, Rel_L2: 5.890e-02, L_inf: 5.890e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9100, Loss: 2.107e-02, Rel_L2: 2.816e-02, L_inf: 2.816e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9200, Loss: 1.309e+00, Rel_L2: 5.439e-02, L_inf: 5.439e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9300, Loss: 9.613e-02, Rel_L2: 3.106e-02, L_inf: 3.106e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9400, Loss: 2.229e-02, Rel_L2: 2.853e-02, L_inf: 2.853e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9500, Loss: 4.424e-01, Rel_L2: 3.687e-02, L_inf: 3.687e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9600, Loss: 2.255e-02, Rel_L2: 2.498e-02, L_inf: 2.498e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9700, Loss: 1.719e-02, Rel_L2: 2.790e-02, L_inf: 2.790e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9800, Loss: 1.230e+00, Rel_L2: 4.576e-02, L_inf: 4.576e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9900, Loss: 2.612e-02, Rel_L2: 2.656e-02, L_inf: 2.656e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10000, Loss: 1.385e-01, Rel_L2: 2.537e-02, L_inf: 2.537e-02, t/iter: 2.5e-02\n",
      "\n",
      "Adjusting learning rate of group 0 to 8.1000e-04.\n",
      "Iter 10100, Loss: 5.558e-03, Rel_L2: 2.325e-02, L_inf: 2.325e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10200, Loss: 5.023e-03, Rel_L2: 2.230e-02, L_inf: 2.230e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10300, Loss: 4.600e-03, Rel_L2: 2.137e-02, L_inf: 2.137e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10400, Loss: 4.241e-03, Rel_L2: 2.053e-02, L_inf: 2.053e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10500, Loss: 3.931e-03, Rel_L2: 1.979e-02, L_inf: 1.979e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10600, Loss: 3.666e-03, Rel_L2: 1.915e-02, L_inf: 1.915e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10700, Loss: 3.437e-03, Rel_L2: 1.860e-02, L_inf: 1.860e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10800, Loss: 3.241e-03, Rel_L2: 1.811e-02, L_inf: 1.811e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10900, Loss: 3.069e-03, Rel_L2: 1.769e-02, L_inf: 1.769e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11000, Loss: 2.918e-03, Rel_L2: 1.733e-02, L_inf: 1.733e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11100, Loss: 2.782e-03, Rel_L2: 1.702e-02, L_inf: 1.702e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11200, Loss: 2.658e-03, Rel_L2: 1.676e-02, L_inf: 1.676e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11300, Loss: 8.922e-03, Rel_L2: 1.712e-02, L_inf: 1.712e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11400, Loss: 2.429e-03, Rel_L2: 1.634e-02, L_inf: 1.634e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11500, Loss: 9.896e-03, Rel_L2: 1.797e-02, L_inf: 1.797e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11600, Loss: 1.847e-01, Rel_L2: 3.333e-02, L_inf: 3.333e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11700, Loss: 1.633e-01, Rel_L2: 3.896e-02, L_inf: 3.896e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11800, Loss: 5.909e-01, Rel_L2: 4.628e-02, L_inf: 4.628e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11900, Loss: 7.638e-01, Rel_L2: 5.134e-02, L_inf: 5.134e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12000, Loss: 2.159e-01, Rel_L2: 3.535e-02, L_inf: 3.535e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12100, Loss: 4.401e-02, Rel_L2: 2.864e-02, L_inf: 2.864e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12200, Loss: 5.805e-01, Rel_L2: 4.940e-02, L_inf: 4.940e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12300, Loss: 2.805e-01, Rel_L2: 3.158e-02, L_inf: 3.158e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12400, Loss: 1.097e+00, Rel_L2: 6.116e-02, L_inf: 6.116e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12500, Loss: 8.557e-02, Rel_L2: 2.521e-02, L_inf: 2.521e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12600, Loss: 1.031e+00, Rel_L2: 4.754e-02, L_inf: 4.754e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12700, Loss: 1.424e-01, Rel_L2: 5.278e-02, L_inf: 5.278e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12800, Loss: 1.131e+00, Rel_L2: 4.978e-02, L_inf: 4.978e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12900, Loss: 8.702e-01, Rel_L2: 4.817e-02, L_inf: 4.817e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13000, Loss: 2.141e+00, Rel_L2: 6.098e-02, L_inf: 6.098e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13100, Loss: 4.590e-01, Rel_L2: 3.230e-02, L_inf: 3.230e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13200, Loss: 1.589e-01, Rel_L2: 2.518e-02, L_inf: 2.518e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13300, Loss: 1.701e-01, Rel_L2: 2.629e-02, L_inf: 2.629e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13400, Loss: 1.282e-02, Rel_L2: 2.090e-02, L_inf: 2.090e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13500, Loss: 1.304e-02, Rel_L2: 2.132e-02, L_inf: 2.132e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13600, Loss: 1.744e-01, Rel_L2: 3.067e-02, L_inf: 3.067e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13700, Loss: 4.866e-02, Rel_L2: 2.533e-02, L_inf: 2.533e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13800, Loss: 5.501e-01, Rel_L2: 3.333e-02, L_inf: 3.333e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13900, Loss: 4.010e-02, Rel_L2: 2.259e-02, L_inf: 2.259e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14000, Loss: 9.460e-03, Rel_L2: 2.044e-02, L_inf: 2.044e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14100, Loss: 3.054e-01, Rel_L2: 2.740e-02, L_inf: 2.740e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14200, Loss: 5.107e-02, Rel_L2: 2.131e-02, L_inf: 2.131e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14300, Loss: 1.410e-02, Rel_L2: 2.021e-02, L_inf: 2.021e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14400, Loss: 2.305e-01, Rel_L2: 2.369e-02, L_inf: 2.369e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14500, Loss: 4.886e-03, Rel_L2: 1.902e-02, L_inf: 1.902e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14600, Loss: 1.926e-01, Rel_L2: 2.542e-02, L_inf: 2.542e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14700, Loss: 8.687e-03, Rel_L2: 1.701e-02, L_inf: 1.701e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14800, Loss: 2.020e-02, Rel_L2: 2.124e-02, L_inf: 2.124e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14900, Loss: 6.144e-01, Rel_L2: 3.196e-02, L_inf: 3.196e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 15000, Loss: 1.581e-01, Rel_L2: 2.472e-02, L_inf: 2.472e-02, t/iter: 2.5e-02\n",
      "\n",
      "Adjusting learning rate of group 0 to 7.2900e-04.\n",
      "Iter 15100, Loss: 2.656e-03, Rel_L2: 1.689e-02, L_inf: 1.689e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 15200, Loss: 2.519e-03, Rel_L2: 1.668e-02, L_inf: 1.668e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 15300, Loss: 2.428e-03, Rel_L2: 1.633e-02, L_inf: 1.633e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 15400, Loss: 2.355e-03, Rel_L2: 1.602e-02, L_inf: 1.602e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 15500, Loss: 2.298e-03, Rel_L2: 1.579e-02, L_inf: 1.579e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 15600, Loss: 7.617e-03, Rel_L2: 1.752e-02, L_inf: 1.752e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 15700, Loss: 2.195e-03, Rel_L2: 1.544e-02, L_inf: 1.544e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 15800, Loss: 1.180e-02, Rel_L2: 2.219e-02, L_inf: 2.219e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 15900, Loss: 2.102e-03, Rel_L2: 1.507e-02, L_inf: 1.507e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16000, Loss: 5.849e-03, Rel_L2: 1.714e-02, L_inf: 1.714e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16100, Loss: 1.995e-03, Rel_L2: 1.473e-02, L_inf: 1.473e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16200, Loss: 4.018e-03, Rel_L2: 1.646e-02, L_inf: 1.646e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16300, Loss: 1.886e-03, Rel_L2: 1.434e-02, L_inf: 1.434e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16400, Loss: 1.444e-02, Rel_L2: 1.707e-02, L_inf: 1.707e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16500, Loss: 2.617e-02, Rel_L2: 1.675e-02, L_inf: 1.675e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16600, Loss: 3.903e-02, Rel_L2: 1.979e-02, L_inf: 1.979e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16700, Loss: 6.535e-02, Rel_L2: 2.113e-02, L_inf: 2.113e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16800, Loss: 1.948e-02, Rel_L2: 1.726e-02, L_inf: 1.726e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16900, Loss: 4.772e-01, Rel_L2: 3.855e-02, L_inf: 3.855e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17000, Loss: 5.298e-01, Rel_L2: 4.104e-02, L_inf: 4.104e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17100, Loss: 1.000e-02, Rel_L2: 1.759e-02, L_inf: 1.759e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17200, Loss: 6.360e-01, Rel_L2: 4.225e-02, L_inf: 4.225e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17300, Loss: 2.530e-02, Rel_L2: 2.007e-02, L_inf: 2.007e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17400, Loss: 6.664e-03, Rel_L2: 1.433e-02, L_inf: 1.433e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17500, Loss: 3.233e-01, Rel_L2: 3.078e-02, L_inf: 3.078e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17600, Loss: 2.791e-01, Rel_L2: 2.628e-02, L_inf: 2.628e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17700, Loss: 4.678e-01, Rel_L2: 3.522e-02, L_inf: 3.522e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17800, Loss: 1.982e-01, Rel_L2: 2.470e-02, L_inf: 2.470e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17900, Loss: 4.531e-02, Rel_L2: 1.631e-02, L_inf: 1.631e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18000, Loss: 3.551e-01, Rel_L2: 3.076e-02, L_inf: 3.076e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18100, Loss: 1.666e-02, Rel_L2: 2.375e-02, L_inf: 2.375e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18200, Loss: 3.347e-01, Rel_L2: 2.949e-02, L_inf: 2.949e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18300, Loss: 8.221e-01, Rel_L2: 3.739e-02, L_inf: 3.739e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18400, Loss: 5.887e-01, Rel_L2: 3.613e-02, L_inf: 3.613e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18500, Loss: 6.801e-01, Rel_L2: 3.362e-02, L_inf: 3.362e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18600, Loss: 7.487e-01, Rel_L2: 3.826e-02, L_inf: 3.826e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18700, Loss: 2.473e-02, Rel_L2: 2.024e-02, L_inf: 2.024e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18800, Loss: 3.001e-02, Rel_L2: 1.863e-02, L_inf: 1.863e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18900, Loss: 2.087e-02, Rel_L2: 1.763e-02, L_inf: 1.763e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19000, Loss: 2.000e-01, Rel_L2: 2.212e-02, L_inf: 2.212e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19100, Loss: 2.533e-01, Rel_L2: 2.326e-02, L_inf: 2.326e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19200, Loss: 2.672e-01, Rel_L2: 2.104e-02, L_inf: 2.104e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19300, Loss: 4.448e-01, Rel_L2: 2.705e-02, L_inf: 2.705e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19400, Loss: 5.224e-02, Rel_L2: 1.466e-02, L_inf: 1.466e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19500, Loss: 7.150e-01, Rel_L2: 3.261e-02, L_inf: 3.261e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19600, Loss: 1.377e-01, Rel_L2: 1.975e-02, L_inf: 1.975e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19700, Loss: 5.299e-02, Rel_L2: 2.003e-02, L_inf: 2.003e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19800, Loss: 3.162e-02, Rel_L2: 1.706e-02, L_inf: 1.706e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19900, Loss: 8.963e-03, Rel_L2: 1.442e-02, L_inf: 1.442e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 20000, Loss: 5.685e-01, Rel_L2: 2.850e-02, L_inf: 2.850e-02, t/iter: 2.5e-02\n",
      "\n",
      "Adjusting learning rate of group 0 to 6.5610e-04.\n",
      "LBFGS switch\n",
      "Iter 20100, Loss: 1.918e-03, Rel_L2: 1.496e-02, L_inf: 1.496e-02, t/iter: 7.2e-02\n",
      "\n",
      "Iter 20200, Loss: 1.462e-03, Rel_L2: 1.294e-02, L_inf: 1.294e-02, t/iter: 7.2e-02\n",
      "\n",
      "Iter 20300, Loss: 1.197e-03, Rel_L2: 1.218e-02, L_inf: 1.218e-02, t/iter: 7.2e-02\n",
      "\n",
      "Iter 20400, Loss: 9.445e-04, Rel_L2: 1.112e-02, L_inf: 1.112e-02, t/iter: 7.2e-02\n",
      "\n",
      "Iter 20500, Loss: 7.739e-04, Rel_L2: 9.749e-03, L_inf: 9.749e-03, t/iter: 7.2e-02\n",
      "\n",
      "Iter 20600, Loss: 6.537e-04, Rel_L2: 8.836e-03, L_inf: 8.836e-03, t/iter: 7.2e-02\n",
      "\n",
      "Iter 20700, Loss: 6.036e-04, Rel_L2: 7.717e-03, L_inf: 7.717e-03, t/iter: 7.2e-02\n",
      "\n",
      "Iter 20800, Loss: 4.895e-04, Rel_L2: 8.021e-03, L_inf: 8.021e-03, t/iter: 7.2e-02\n",
      "\n",
      "Iter 20900, Loss: 4.143e-04, Rel_L2: 7.185e-03, L_inf: 7.185e-03, t/iter: 7.2e-02\n",
      "\n",
      "Iter 21000, Loss: 3.429e-04, Rel_L2: 6.249e-03, L_inf: 6.249e-03, t/iter: 7.2e-02\n",
      "\n",
      "Iter 21100, Loss: 2.913e-04, Rel_L2: 6.159e-03, L_inf: 6.159e-03, t/iter: 7.2e-02\n",
      "\n",
      "Iter 21200, Loss: 2.428e-04, Rel_L2: 4.874e-03, L_inf: 4.874e-03, t/iter: 7.2e-02\n",
      "\n",
      "Iter 21300, Loss: 2.083e-04, Rel_L2: 4.506e-03, L_inf: 4.506e-03, t/iter: 7.2e-02\n",
      "\n",
      "Iter 21400, Loss: 1.885e-04, Rel_L2: 4.064e-03, L_inf: 4.064e-03, t/iter: 7.2e-02\n",
      "\n",
      "Iter 21500, Loss: 1.662e-04, Rel_L2: 3.553e-03, L_inf: 3.553e-03, t/iter: 7.2e-02\n",
      "\n",
      "Iter 21600, Loss: 1.500e-04, Rel_L2: 3.383e-03, L_inf: 3.383e-03, t/iter: 7.2e-02\n",
      "\n",
      "Iter 21700, Loss: 1.402e-04, Rel_L2: 3.074e-03, L_inf: 3.074e-03, t/iter: 7.2e-02\n",
      "\n",
      "Iter 21800, Loss: 1.330e-04, Rel_L2: 2.943e-03, L_inf: 2.943e-03, t/iter: 7.2e-02\n",
      "\n",
      "CPU times: user 9min 16s, sys: 2.12 s, total: 9min 18s\n",
      "Wall time: 9min 26s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "model.train() # RBA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iter 100, Loss: 5.125e+03, Rel_L2: 4.735e+00, L_inf: 4.735e+00, t/iter: 2.5e-02\n",
      "\n",
      "Iter 200, Loss: 8.937e+03, Rel_L2: 2.631e+00, L_inf: 2.631e+00, t/iter: 2.5e-02\n",
      "\n",
      "Iter 300, Loss: 3.779e+03, Rel_L2: 4.358e+00, L_inf: 4.358e+00, t/iter: 2.5e-02\n",
      "\n",
      "Iter 400, Loss: 1.625e+02, Rel_L2: 4.998e+00, L_inf: 4.998e+00, t/iter: 2.5e-02\n",
      "\n",
      "Iter 500, Loss: 5.311e+01, Rel_L2: 2.087e+00, L_inf: 2.087e+00, t/iter: 2.5e-02\n",
      "\n",
      "Iter 600, Loss: 3.943e+02, Rel_L2: 1.225e+00, L_inf: 1.225e+00, t/iter: 2.5e-02\n",
      "\n",
      "Iter 700, Loss: 1.429e+02, Rel_L2: 9.233e-01, L_inf: 9.233e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 800, Loss: 2.794e+01, Rel_L2: 7.624e-01, L_inf: 7.624e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 900, Loss: 8.294e+02, Rel_L2: 6.922e-01, L_inf: 6.922e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 1000, Loss: 2.728e+02, Rel_L2: 6.631e-01, L_inf: 6.631e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 1100, Loss: 9.536e+02, Rel_L2: 6.383e-01, L_inf: 6.383e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 1200, Loss: 2.032e+02, Rel_L2: 6.216e-01, L_inf: 6.216e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 1300, Loss: 6.972e+02, Rel_L2: 6.222e-01, L_inf: 6.222e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 1400, Loss: 3.929e+02, Rel_L2: 6.058e-01, L_inf: 6.058e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 1500, Loss: 1.200e+03, Rel_L2: 5.711e-01, L_inf: 5.711e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 1600, Loss: 1.028e+02, Rel_L2: 5.584e-01, L_inf: 5.584e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 1700, Loss: 1.027e+03, Rel_L2: 5.490e-01, L_inf: 5.490e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 1800, Loss: 4.894e+02, Rel_L2: 5.377e-01, L_inf: 5.377e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 1900, Loss: 1.503e+03, Rel_L2: 5.636e-01, L_inf: 5.636e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2000, Loss: 1.504e+03, Rel_L2: 5.310e-01, L_inf: 5.310e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2100, Loss: 1.626e+03, Rel_L2: 5.196e-01, L_inf: 5.196e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2200, Loss: 1.059e+03, Rel_L2: 5.065e-01, L_inf: 5.065e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2300, Loss: 1.267e+03, Rel_L2: 4.892e-01, L_inf: 4.892e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2400, Loss: 1.202e+03, Rel_L2: 5.060e-01, L_inf: 5.060e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2500, Loss: 1.772e+03, Rel_L2: 4.973e-01, L_inf: 4.973e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2600, Loss: 1.937e+03, Rel_L2: 4.870e-01, L_inf: 4.870e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2700, Loss: 1.093e+03, Rel_L2: 4.697e-01, L_inf: 4.697e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2800, Loss: 8.722e+02, Rel_L2: 4.504e-01, L_inf: 4.504e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2900, Loss: 1.033e+03, Rel_L2: 4.294e-01, L_inf: 4.294e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3000, Loss: 2.073e+03, Rel_L2: 4.268e-01, L_inf: 4.268e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3100, Loss: 2.620e+03, Rel_L2: 4.250e-01, L_inf: 4.250e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3200, Loss: 2.511e+03, Rel_L2: 4.308e-01, L_inf: 4.308e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3300, Loss: 2.689e+03, Rel_L2: 4.224e-01, L_inf: 4.224e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3400, Loss: 2.418e+03, Rel_L2: 3.947e-01, L_inf: 3.947e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3500, Loss: 1.658e+03, Rel_L2: 3.659e-01, L_inf: 3.659e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3600, Loss: 1.130e+03, Rel_L2: 3.650e-01, L_inf: 3.650e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3700, Loss: 1.219e+03, Rel_L2: 3.236e-01, L_inf: 3.236e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3800, Loss: 2.810e+03, Rel_L2: 3.208e-01, L_inf: 3.208e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3900, Loss: 1.108e+03, Rel_L2: 2.862e-01, L_inf: 2.862e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4000, Loss: 2.784e+03, Rel_L2: 2.717e-01, L_inf: 2.717e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4100, Loss: 6.043e+03, Rel_L2: 2.906e-01, L_inf: 2.906e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4200, Loss: 2.512e+03, Rel_L2: 2.982e-01, L_inf: 2.982e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4300, Loss: 1.750e+03, Rel_L2: 2.990e-01, L_inf: 2.990e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4400, Loss: 2.198e+03, Rel_L2: 2.806e-01, L_inf: 2.806e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4500, Loss: 8.146e+02, Rel_L2: 2.743e-01, L_inf: 2.743e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4600, Loss: 2.891e+03, Rel_L2: 2.448e-01, L_inf: 2.448e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4700, Loss: 3.432e+03, Rel_L2: 2.364e-01, L_inf: 2.364e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4800, Loss: 4.647e+02, Rel_L2: 2.265e-01, L_inf: 2.265e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4900, Loss: 1.796e+02, Rel_L2: 2.150e-01, L_inf: 2.150e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5000, Loss: 2.236e+02, Rel_L2: 2.113e-01, L_inf: 2.113e-01, t/iter: 2.5e-02\n",
      "\n",
      "Adjusting learning rate of group 0 to 9.0000e-04.\n",
      "Iter 5100, Loss: 4.110e+01, Rel_L2: 1.872e-01, L_inf: 1.872e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5200, Loss: 3.637e+01, Rel_L2: 1.711e-01, L_inf: 1.711e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5300, Loss: 3.799e+02, Rel_L2: 1.854e-01, L_inf: 1.854e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5400, Loss: 3.238e+03, Rel_L2: 2.071e-01, L_inf: 2.071e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5500, Loss: 7.179e+02, Rel_L2: 1.748e-01, L_inf: 1.748e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5600, Loss: 6.644e+02, Rel_L2: 1.765e-01, L_inf: 1.765e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5700, Loss: 5.857e+02, Rel_L2: 1.833e-01, L_inf: 1.833e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5800, Loss: 1.377e+03, Rel_L2: 1.907e-01, L_inf: 1.907e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5900, Loss: 1.069e+03, Rel_L2: 1.666e-01, L_inf: 1.666e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6000, Loss: 2.487e+02, Rel_L2: 1.628e-01, L_inf: 1.628e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6100, Loss: 6.633e+02, Rel_L2: 1.629e-01, L_inf: 1.629e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6200, Loss: 1.177e+03, Rel_L2: 1.589e-01, L_inf: 1.589e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6300, Loss: 4.695e+02, Rel_L2: 1.603e-01, L_inf: 1.603e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6400, Loss: 1.070e+02, Rel_L2: 1.555e-01, L_inf: 1.555e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6500, Loss: 7.769e+01, Rel_L2: 1.511e-01, L_inf: 1.511e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6600, Loss: 3.245e+03, Rel_L2: 1.900e-01, L_inf: 1.900e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6700, Loss: 1.498e+03, Rel_L2: 1.489e-01, L_inf: 1.489e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6800, Loss: 1.463e+02, Rel_L2: 1.433e-01, L_inf: 1.433e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6900, Loss: 2.462e+03, Rel_L2: 1.787e-01, L_inf: 1.787e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7000, Loss: 9.444e+02, Rel_L2: 1.374e-01, L_inf: 1.374e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7100, Loss: 2.437e+03, Rel_L2: 1.594e-01, L_inf: 1.594e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7200, Loss: 5.941e+01, Rel_L2: 1.392e-01, L_inf: 1.392e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7300, Loss: 4.915e+03, Rel_L2: 1.407e-01, L_inf: 1.407e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7400, Loss: 4.230e+03, Rel_L2: 1.443e-01, L_inf: 1.443e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7500, Loss: 4.869e+02, Rel_L2: 1.413e-01, L_inf: 1.413e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7600, Loss: 3.915e+02, Rel_L2: 1.401e-01, L_inf: 1.401e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7700, Loss: 1.670e+03, Rel_L2: 1.463e-01, L_inf: 1.463e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7800, Loss: 5.489e+02, Rel_L2: 1.359e-01, L_inf: 1.359e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7900, Loss: 3.410e+03, Rel_L2: 1.371e-01, L_inf: 1.371e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8000, Loss: 1.192e+02, Rel_L2: 1.408e-01, L_inf: 1.408e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8100, Loss: 4.117e+02, Rel_L2: 1.322e-01, L_inf: 1.322e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8200, Loss: 4.526e+03, Rel_L2: 1.323e-01, L_inf: 1.323e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8300, Loss: 3.491e+03, Rel_L2: 1.309e-01, L_inf: 1.309e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8400, Loss: 1.245e+03, Rel_L2: 1.313e-01, L_inf: 1.313e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8500, Loss: 4.733e+03, Rel_L2: 1.357e-01, L_inf: 1.357e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8600, Loss: 2.415e+03, Rel_L2: 1.290e-01, L_inf: 1.290e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8700, Loss: 1.594e+02, Rel_L2: 1.288e-01, L_inf: 1.288e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8800, Loss: 4.410e+03, Rel_L2: 1.245e-01, L_inf: 1.245e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8900, Loss: 7.436e+03, Rel_L2: 1.287e-01, L_inf: 1.287e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9000, Loss: 5.184e+03, Rel_L2: 1.214e-01, L_inf: 1.214e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9100, Loss: 2.690e+02, Rel_L2: 1.065e-01, L_inf: 1.065e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9200, Loss: 1.535e+03, Rel_L2: 1.197e-01, L_inf: 1.197e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9300, Loss: 1.609e+02, Rel_L2: 1.044e-01, L_inf: 1.044e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9400, Loss: 2.086e+03, Rel_L2: 1.051e-01, L_inf: 1.051e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9500, Loss: 4.916e+03, Rel_L2: 1.184e-01, L_inf: 1.184e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9600, Loss: 6.091e+02, Rel_L2: 9.826e-02, L_inf: 9.826e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9700, Loss: 5.801e+02, Rel_L2: 1.107e-01, L_inf: 1.107e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9800, Loss: 2.610e+03, Rel_L2: 9.220e-02, L_inf: 9.220e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9900, Loss: 7.114e+03, Rel_L2: 9.996e-02, L_inf: 9.996e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10000, Loss: 2.700e+02, Rel_L2: 8.819e-02, L_inf: 8.819e-02, t/iter: 2.5e-02\n",
      "\n",
      "Adjusting learning rate of group 0 to 8.1000e-04.\n",
      "Iter 10100, Loss: 3.979e+01, Rel_L2: 7.470e-02, L_inf: 7.470e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10200, Loss: 3.607e+01, Rel_L2: 7.031e-02, L_inf: 7.031e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10300, Loss: 3.138e+03, Rel_L2: 8.338e-02, L_inf: 8.338e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10400, Loss: 7.005e+03, Rel_L2: 8.950e-02, L_inf: 8.950e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10500, Loss: 8.027e+02, Rel_L2: 8.189e-02, L_inf: 8.189e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10600, Loss: 1.525e+03, Rel_L2: 7.626e-02, L_inf: 7.626e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10700, Loss: 4.109e+02, Rel_L2: 7.418e-02, L_inf: 7.418e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10800, Loss: 3.358e+02, Rel_L2: 6.901e-02, L_inf: 6.901e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10900, Loss: 5.422e+03, Rel_L2: 9.321e-02, L_inf: 9.321e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11000, Loss: 2.048e+02, Rel_L2: 6.330e-02, L_inf: 6.330e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11100, Loss: 7.713e+03, Rel_L2: 7.826e-02, L_inf: 7.826e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11200, Loss: 2.906e+03, Rel_L2: 7.066e-02, L_inf: 7.066e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11300, Loss: 1.876e+03, Rel_L2: 6.344e-02, L_inf: 6.344e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11400, Loss: 5.252e+03, Rel_L2: 6.612e-02, L_inf: 6.612e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11500, Loss: 4.124e+02, Rel_L2: 6.074e-02, L_inf: 6.074e-02, t/iter: 2.6e-02\n",
      "\n",
      "Iter 11600, Loss: 2.543e+02, Rel_L2: 5.510e-02, L_inf: 5.510e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11700, Loss: 1.416e+04, Rel_L2: 8.005e-02, L_inf: 8.005e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11800, Loss: 1.814e+03, Rel_L2: 5.596e-02, L_inf: 5.596e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11900, Loss: 9.724e+02, Rel_L2: 5.877e-02, L_inf: 5.877e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12000, Loss: 1.692e+03, Rel_L2: 5.752e-02, L_inf: 5.752e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12100, Loss: 3.023e+03, Rel_L2: 5.486e-02, L_inf: 5.486e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12200, Loss: 4.259e+03, Rel_L2: 6.085e-02, L_inf: 6.085e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12300, Loss: 2.511e+03, Rel_L2: 5.215e-02, L_inf: 5.215e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12400, Loss: 6.313e+03, Rel_L2: 5.804e-02, L_inf: 5.804e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12500, Loss: 3.770e+03, Rel_L2: 6.356e-02, L_inf: 6.356e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12600, Loss: 2.843e+03, Rel_L2: 5.216e-02, L_inf: 5.216e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12700, Loss: 7.638e+03, Rel_L2: 5.941e-02, L_inf: 5.941e-02, t/iter: 2.6e-02\n",
      "\n",
      "Iter 12800, Loss: 5.334e+03, Rel_L2: 5.601e-02, L_inf: 5.601e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12900, Loss: 3.250e+02, Rel_L2: 4.324e-02, L_inf: 4.324e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13000, Loss: 3.975e+03, Rel_L2: 5.439e-02, L_inf: 5.439e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13100, Loss: 5.801e+02, Rel_L2: 4.489e-02, L_inf: 4.489e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13200, Loss: 4.080e+03, Rel_L2: 5.580e-02, L_inf: 5.580e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13300, Loss: 3.917e+03, Rel_L2: 4.817e-02, L_inf: 4.817e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13400, Loss: 4.745e+03, Rel_L2: 5.062e-02, L_inf: 5.062e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13500, Loss: 7.565e+02, Rel_L2: 4.734e-02, L_inf: 4.734e-02, t/iter: 2.6e-02\n",
      "\n",
      "Iter 13600, Loss: 1.105e+04, Rel_L2: 6.062e-02, L_inf: 6.062e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13700, Loss: 1.001e+03, Rel_L2: 4.155e-02, L_inf: 4.155e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13800, Loss: 2.914e+03, Rel_L2: 4.975e-02, L_inf: 4.975e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13900, Loss: 7.232e+03, Rel_L2: 5.334e-02, L_inf: 5.334e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14000, Loss: 1.564e+03, Rel_L2: 4.048e-02, L_inf: 4.048e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14100, Loss: 2.423e+02, Rel_L2: 3.931e-02, L_inf: 3.931e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14200, Loss: 4.386e+03, Rel_L2: 4.508e-02, L_inf: 4.508e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14300, Loss: 3.663e+03, Rel_L2: 4.460e-02, L_inf: 4.460e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14400, Loss: 4.736e+02, Rel_L2: 3.991e-02, L_inf: 3.991e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14500, Loss: 1.920e+03, Rel_L2: 4.163e-02, L_inf: 4.163e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14600, Loss: 1.276e+03, Rel_L2: 4.187e-02, L_inf: 4.187e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14700, Loss: 6.383e+02, Rel_L2: 3.811e-02, L_inf: 3.811e-02, t/iter: 2.6e-02\n",
      "\n",
      "Iter 14800, Loss: 1.161e+03, Rel_L2: 4.032e-02, L_inf: 4.032e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14900, Loss: 5.284e+02, Rel_L2: 3.873e-02, L_inf: 3.873e-02, t/iter: 2.6e-02\n",
      "\n",
      "Iter 15000, Loss: 8.144e+03, Rel_L2: 5.327e-02, L_inf: 5.327e-02, t/iter: 2.6e-02\n",
      "\n",
      "Adjusting learning rate of group 0 to 7.2900e-04.\n",
      "Iter 15100, Loss: 5.302e+01, Rel_L2: 3.552e-02, L_inf: 3.552e-02, t/iter: 2.7e-02\n",
      "\n",
      "Iter 15200, Loss: 4.883e+01, Rel_L2: 3.558e-02, L_inf: 3.558e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 15300, Loss: 1.607e+03, Rel_L2: 3.837e-02, L_inf: 3.837e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 15400, Loss: 8.485e+03, Rel_L2: 4.827e-02, L_inf: 4.827e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 15500, Loss: 3.285e+03, Rel_L2: 4.400e-02, L_inf: 4.400e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 15600, Loss: 1.923e+03, Rel_L2: 3.738e-02, L_inf: 3.738e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 15700, Loss: 1.091e+03, Rel_L2: 3.811e-02, L_inf: 3.811e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 15800, Loss: 7.049e+02, Rel_L2: 3.552e-02, L_inf: 3.552e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 15900, Loss: 6.149e+03, Rel_L2: 4.143e-02, L_inf: 4.143e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16000, Loss: 5.149e+03, Rel_L2: 4.227e-02, L_inf: 4.227e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16100, Loss: 2.764e+02, Rel_L2: 3.409e-02, L_inf: 3.409e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16200, Loss: 2.484e+03, Rel_L2: 4.416e-02, L_inf: 4.416e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16300, Loss: 4.547e+02, Rel_L2: 3.556e-02, L_inf: 3.556e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16400, Loss: 1.093e+03, Rel_L2: 3.722e-02, L_inf: 3.722e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16500, Loss: 2.739e+03, Rel_L2: 3.811e-02, L_inf: 3.811e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16600, Loss: 8.084e+02, Rel_L2: 3.791e-02, L_inf: 3.791e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16700, Loss: 4.661e+02, Rel_L2: 3.333e-02, L_inf: 3.333e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16800, Loss: 1.201e+03, Rel_L2: 3.749e-02, L_inf: 3.749e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16900, Loss: 4.964e+03, Rel_L2: 3.866e-02, L_inf: 3.866e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17000, Loss: 2.814e+03, Rel_L2: 3.644e-02, L_inf: 3.644e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17100, Loss: 7.473e+03, Rel_L2: 4.401e-02, L_inf: 4.401e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17200, Loss: 8.386e+03, Rel_L2: 4.409e-02, L_inf: 4.409e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17300, Loss: 8.835e+03, Rel_L2: 4.565e-02, L_inf: 4.565e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17400, Loss: 2.333e+03, Rel_L2: 4.466e-02, L_inf: 4.466e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17500, Loss: 7.905e+03, Rel_L2: 4.327e-02, L_inf: 4.327e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17600, Loss: 1.423e+04, Rel_L2: 5.074e-02, L_inf: 5.074e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17700, Loss: 5.258e+02, Rel_L2: 3.443e-02, L_inf: 3.443e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17800, Loss: 1.725e+03, Rel_L2: 3.844e-02, L_inf: 3.844e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17900, Loss: 6.376e+03, Rel_L2: 3.979e-02, L_inf: 3.979e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18000, Loss: 2.483e+03, Rel_L2: 3.544e-02, L_inf: 3.544e-02, t/iter: 2.6e-02\n",
      "\n",
      "Iter 18100, Loss: 7.071e+02, Rel_L2: 3.231e-02, L_inf: 3.231e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18200, Loss: 2.818e+03, Rel_L2: 3.601e-02, L_inf: 3.601e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18300, Loss: 6.892e+02, Rel_L2: 3.307e-02, L_inf: 3.307e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18400, Loss: 2.842e+03, Rel_L2: 3.746e-02, L_inf: 3.746e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18500, Loss: 1.371e+03, Rel_L2: 3.499e-02, L_inf: 3.499e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18600, Loss: 3.554e+03, Rel_L2: 3.671e-02, L_inf: 3.671e-02, t/iter: 2.6e-02\n",
      "\n",
      "Iter 18700, Loss: 1.938e+03, Rel_L2: 3.721e-02, L_inf: 3.721e-02, t/iter: 2.6e-02\n",
      "\n",
      "Iter 18800, Loss: 7.270e+03, Rel_L2: 4.447e-02, L_inf: 4.447e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18900, Loss: 1.001e+03, Rel_L2: 3.693e-02, L_inf: 3.693e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19000, Loss: 9.741e+02, Rel_L2: 3.517e-02, L_inf: 3.517e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19100, Loss: 4.967e+02, Rel_L2: 3.370e-02, L_inf: 3.370e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19200, Loss: 1.356e+04, Rel_L2: 4.688e-02, L_inf: 4.688e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19300, Loss: 5.771e+03, Rel_L2: 3.921e-02, L_inf: 3.921e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19400, Loss: 2.012e+02, Rel_L2: 3.405e-02, L_inf: 3.405e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19500, Loss: 5.238e+03, Rel_L2: 4.019e-02, L_inf: 4.019e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19600, Loss: 1.417e+03, Rel_L2: 3.502e-02, L_inf: 3.502e-02, t/iter: 2.6e-02\n",
      "\n",
      "Iter 19700, Loss: 3.867e+03, Rel_L2: 3.514e-02, L_inf: 3.514e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19800, Loss: 1.028e+03, Rel_L2: 3.385e-02, L_inf: 3.385e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19900, Loss: 1.054e+04, Rel_L2: 4.456e-02, L_inf: 4.456e-02, t/iter: 2.5e-02\n",
      "\n",
      "Iter 20000, Loss: 2.772e+02, Rel_L2: 3.399e-02, L_inf: 3.399e-02, t/iter: 2.5e-02\n",
      "\n",
      "Adjusting learning rate of group 0 to 6.5610e-04.\n",
      "LBFGS switch\n",
      "Iter 20100, Loss: 2.869e-02, Rel_L2: 2.935e-02, L_inf: 2.935e-02, t/iter: 7.3e-02\n",
      "\n",
      "Iter 20200, Loss: 2.193e-02, Rel_L2: 3.013e-02, L_inf: 3.013e-02, t/iter: 7.3e-02\n",
      "\n",
      "Iter 20300, Loss: 1.696e-02, Rel_L2: 3.557e-02, L_inf: 3.557e-02, t/iter: 7.3e-02\n",
      "\n",
      "Iter 20400, Loss: 1.294e-02, Rel_L2: 3.142e-02, L_inf: 3.142e-02, t/iter: 7.3e-02\n",
      "\n",
      "Iter 20500, Loss: 1.042e-02, Rel_L2: 3.007e-02, L_inf: 3.007e-02, t/iter: 7.3e-02\n",
      "\n",
      "Iter 20600, Loss: 8.696e-03, Rel_L2: 2.869e-02, L_inf: 2.869e-02, t/iter: 7.3e-02\n",
      "\n",
      "Iter 20700, Loss: 7.325e-03, Rel_L2: 2.838e-02, L_inf: 2.838e-02, t/iter: 7.3e-02\n",
      "\n",
      "Iter 20800, Loss: 6.114e-03, Rel_L2: 2.790e-02, L_inf: 2.790e-02, t/iter: 7.3e-02\n",
      "\n",
      "Iter 20900, Loss: 5.204e-03, Rel_L2: 2.676e-02, L_inf: 2.676e-02, t/iter: 7.3e-02\n",
      "\n",
      "Iter 21000, Loss: 4.575e-03, Rel_L2: 2.611e-02, L_inf: 2.611e-02, t/iter: 7.3e-02\n",
      "\n",
      "Iter 21100, Loss: 4.007e-03, Rel_L2: 2.390e-02, L_inf: 2.390e-02, t/iter: 7.3e-02\n",
      "\n",
      "Iter 21200, Loss: 3.479e-03, Rel_L2: 2.220e-02, L_inf: 2.220e-02, t/iter: 7.3e-02\n",
      "\n",
      "Iter 21300, Loss: 3.032e-03, Rel_L2: 2.173e-02, L_inf: 2.173e-02, t/iter: 7.3e-02\n",
      "\n",
      "Iter 21400, Loss: 2.696e-03, Rel_L2: 1.991e-02, L_inf: 1.991e-02, t/iter: 7.3e-02\n",
      "\n",
      "Iter 21500, Loss: 2.463e-03, Rel_L2: 1.809e-02, L_inf: 1.809e-02, t/iter: 7.3e-02\n",
      "\n",
      "Iter 21600, Loss: 2.219e-03, Rel_L2: 1.717e-02, L_inf: 1.717e-02, t/iter: 7.3e-02\n",
      "\n",
      "Iter 21700, Loss: 2.015e-03, Rel_L2: 1.566e-02, L_inf: 1.566e-02, t/iter: 7.3e-02\n",
      "\n",
      "Iter 21800, Loss: 1.858e-03, Rel_L2: 1.515e-02, L_inf: 1.515e-02, t/iter: 7.3e-02\n",
      "\n",
      "Iter 21900, Loss: 1.692e-03, Rel_L2: 1.365e-02, L_inf: 1.365e-02, t/iter: 7.3e-02\n",
      "\n",
      "Iter 22000, Loss: 1.531e-03, Rel_L2: 1.379e-02, L_inf: 1.379e-02, t/iter: 7.3e-02\n",
      "\n",
      "CPU times: user 9min 30s, sys: 3 s, total: 9min 33s\n",
      "Wall time: 9min 43s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "model.train() # SA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iter 100, Loss: 4.399e+03, Rel_L2: 3.691e+00, L_inf: 3.691e+00, t/iter: 2.5e-02\n",
      "\n",
      "Iter 200, Loss: 2.809e+03, Rel_L2: 2.351e+00, L_inf: 2.351e+00, t/iter: 2.5e-02\n",
      "\n",
      "Iter 300, Loss: 1.422e+03, Rel_L2: 1.570e+00, L_inf: 1.570e+00, t/iter: 2.5e-02\n",
      "\n",
      "Iter 400, Loss: 4.874e+02, Rel_L2: 3.628e+00, L_inf: 3.628e+00, t/iter: 2.5e-02\n",
      "\n",
      "Iter 500, Loss: 8.980e+01, Rel_L2: 2.771e+00, L_inf: 2.771e+00, t/iter: 2.5e-02\n",
      "\n",
      "Iter 600, Loss: 4.517e+01, Rel_L2: 2.062e+00, L_inf: 2.062e+00, t/iter: 2.5e-02\n",
      "\n",
      "Iter 700, Loss: 7.675e+00, Rel_L2: 1.651e+00, L_inf: 1.651e+00, t/iter: 2.5e-02\n",
      "\n",
      "Iter 800, Loss: 3.633e+00, Rel_L2: 1.346e+00, L_inf: 1.346e+00, t/iter: 2.5e-02\n",
      "\n",
      "Iter 900, Loss: 1.159e+01, Rel_L2: 1.151e+00, L_inf: 1.151e+00, t/iter: 2.5e-02\n",
      "\n",
      "Iter 1000, Loss: 3.574e+01, Rel_L2: 1.016e+00, L_inf: 1.016e+00, t/iter: 2.5e-02\n",
      "\n",
      "Iter 1100, Loss: 1.713e+01, Rel_L2: 9.161e-01, L_inf: 9.161e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 1200, Loss: 1.091e+01, Rel_L2: 8.547e-01, L_inf: 8.547e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 1300, Loss: 7.224e+01, Rel_L2: 8.159e-01, L_inf: 8.159e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 1400, Loss: 3.338e+00, Rel_L2: 7.685e-01, L_inf: 7.685e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 1500, Loss: 4.062e+01, Rel_L2: 7.397e-01, L_inf: 7.397e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 1600, Loss: 3.629e+01, Rel_L2: 7.016e-01, L_inf: 7.016e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 1700, Loss: 7.071e+01, Rel_L2: 6.834e-01, L_inf: 6.834e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 1800, Loss: 9.684e+00, Rel_L2: 6.667e-01, L_inf: 6.667e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 1900, Loss: 1.523e+02, Rel_L2: 6.496e-01, L_inf: 6.496e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2000, Loss: 5.329e+00, Rel_L2: 6.345e-01, L_inf: 6.345e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2100, Loss: 2.061e+01, Rel_L2: 6.266e-01, L_inf: 6.266e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2200, Loss: 1.343e+01, Rel_L2: 6.070e-01, L_inf: 6.070e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2300, Loss: 1.665e+00, Rel_L2: 5.962e-01, L_inf: 5.962e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2400, Loss: 1.140e+01, Rel_L2: 5.873e-01, L_inf: 5.873e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2500, Loss: 2.851e+01, Rel_L2: 5.949e-01, L_inf: 5.949e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2600, Loss: 1.424e+01, Rel_L2: 5.732e-01, L_inf: 5.732e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2700, Loss: 2.672e+01, Rel_L2: 5.669e-01, L_inf: 5.669e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2800, Loss: 3.803e+00, Rel_L2: 5.543e-01, L_inf: 5.543e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 2900, Loss: 4.145e+01, Rel_L2: 5.577e-01, L_inf: 5.577e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3000, Loss: 1.189e+00, Rel_L2: 5.347e-01, L_inf: 5.347e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3100, Loss: 3.501e+00, Rel_L2: 5.308e-01, L_inf: 5.308e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3200, Loss: 5.930e+00, Rel_L2: 5.189e-01, L_inf: 5.189e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3300, Loss: 5.551e+00, Rel_L2: 5.161e-01, L_inf: 5.161e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3400, Loss: 2.330e+00, Rel_L2: 5.016e-01, L_inf: 5.016e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3500, Loss: 5.169e+00, Rel_L2: 5.034e-01, L_inf: 5.034e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3600, Loss: 2.682e+00, Rel_L2: 4.933e-01, L_inf: 4.933e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3700, Loss: 3.534e+01, Rel_L2: 4.828e-01, L_inf: 4.828e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3800, Loss: 1.537e+01, Rel_L2: 4.757e-01, L_inf: 4.757e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 3900, Loss: 2.894e+01, Rel_L2: 4.746e-01, L_inf: 4.746e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4000, Loss: 2.749e+00, Rel_L2: 4.599e-01, L_inf: 4.599e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4100, Loss: 7.816e+00, Rel_L2: 4.614e-01, L_inf: 4.614e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4200, Loss: 1.272e+01, Rel_L2: 4.534e-01, L_inf: 4.534e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4300, Loss: 1.020e+01, Rel_L2: 4.497e-01, L_inf: 4.497e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4400, Loss: 1.274e+01, Rel_L2: 4.386e-01, L_inf: 4.386e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4500, Loss: 1.595e+00, Rel_L2: 4.334e-01, L_inf: 4.334e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4600, Loss: 3.320e+01, Rel_L2: 4.352e-01, L_inf: 4.352e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4700, Loss: 2.079e+01, Rel_L2: 4.355e-01, L_inf: 4.355e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4800, Loss: 9.558e-01, Rel_L2: 4.107e-01, L_inf: 4.107e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 4900, Loss: 4.617e+00, Rel_L2: 4.112e-01, L_inf: 4.112e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5000, Loss: 8.621e-01, Rel_L2: 4.178e-01, L_inf: 4.178e-01, t/iter: 2.5e-02\n",
      "\n",
      "Adjusting learning rate of group 0 to 9.0000e-04.\n",
      "Iter 5100, Loss: 3.554e-01, Rel_L2: 3.930e-01, L_inf: 3.930e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5200, Loss: 3.313e-01, Rel_L2: 3.837e-01, L_inf: 3.837e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5300, Loss: 1.984e+00, Rel_L2: 3.842e-01, L_inf: 3.842e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5400, Loss: 5.248e+01, Rel_L2: 3.924e-01, L_inf: 3.924e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5500, Loss: 1.040e+01, Rel_L2: 3.775e-01, L_inf: 3.775e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5600, Loss: 9.302e-01, Rel_L2: 3.705e-01, L_inf: 3.705e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5700, Loss: 1.145e+00, Rel_L2: 3.754e-01, L_inf: 3.754e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5800, Loss: 2.581e+00, Rel_L2: 3.650e-01, L_inf: 3.650e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 5900, Loss: 3.430e+00, Rel_L2: 3.636e-01, L_inf: 3.636e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6000, Loss: 7.737e-01, Rel_L2: 3.654e-01, L_inf: 3.654e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6100, Loss: 4.272e+00, Rel_L2: 3.597e-01, L_inf: 3.597e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6200, Loss: 4.030e+00, Rel_L2: 3.573e-01, L_inf: 3.573e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6300, Loss: 3.102e+01, Rel_L2: 3.688e-01, L_inf: 3.688e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6400, Loss: 9.264e+00, Rel_L2: 3.474e-01, L_inf: 3.474e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6500, Loss: 7.379e+00, Rel_L2: 3.558e-01, L_inf: 3.558e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6600, Loss: 7.675e+00, Rel_L2: 3.414e-01, L_inf: 3.414e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6700, Loss: 6.961e+00, Rel_L2: 3.356e-01, L_inf: 3.356e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6800, Loss: 6.883e-01, Rel_L2: 3.336e-01, L_inf: 3.336e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 6900, Loss: 8.092e+00, Rel_L2: 3.332e-01, L_inf: 3.332e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7000, Loss: 1.417e+01, Rel_L2: 3.314e-01, L_inf: 3.314e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7100, Loss: 4.801e+00, Rel_L2: 3.302e-01, L_inf: 3.302e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7200, Loss: 3.330e+00, Rel_L2: 3.233e-01, L_inf: 3.233e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7300, Loss: 1.382e+00, Rel_L2: 3.203e-01, L_inf: 3.203e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7400, Loss: 9.283e+00, Rel_L2: 3.200e-01, L_inf: 3.200e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7500, Loss: 5.084e-01, Rel_L2: 3.172e-01, L_inf: 3.172e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7600, Loss: 4.873e+00, Rel_L2: 3.143e-01, L_inf: 3.143e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7700, Loss: 7.544e-01, Rel_L2: 3.109e-01, L_inf: 3.109e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7800, Loss: 1.897e+01, Rel_L2: 3.223e-01, L_inf: 3.223e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 7900, Loss: 3.154e+00, Rel_L2: 3.049e-01, L_inf: 3.049e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8000, Loss: 3.527e+00, Rel_L2: 3.107e-01, L_inf: 3.107e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8100, Loss: 6.632e-01, Rel_L2: 3.010e-01, L_inf: 3.010e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8200, Loss: 1.881e+00, Rel_L2: 2.992e-01, L_inf: 2.992e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8300, Loss: 1.336e+01, Rel_L2: 3.027e-01, L_inf: 3.027e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8400, Loss: 1.560e+01, Rel_L2: 3.129e-01, L_inf: 3.129e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8500, Loss: 1.246e+00, Rel_L2: 2.918e-01, L_inf: 2.918e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8600, Loss: 5.084e+00, Rel_L2: 2.873e-01, L_inf: 2.873e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8700, Loss: 2.501e+00, Rel_L2: 2.877e-01, L_inf: 2.877e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8800, Loss: 1.465e+00, Rel_L2: 2.807e-01, L_inf: 2.807e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 8900, Loss: 8.632e+00, Rel_L2: 2.795e-01, L_inf: 2.795e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9000, Loss: 5.566e+00, Rel_L2: 2.780e-01, L_inf: 2.780e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9100, Loss: 4.556e+01, Rel_L2: 2.979e-01, L_inf: 2.979e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9200, Loss: 7.448e+00, Rel_L2: 2.764e-01, L_inf: 2.764e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9300, Loss: 1.264e+01, Rel_L2: 2.759e-01, L_inf: 2.759e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9400, Loss: 7.190e+00, Rel_L2: 2.710e-01, L_inf: 2.710e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9500, Loss: 4.792e+00, Rel_L2: 2.682e-01, L_inf: 2.682e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9600, Loss: 1.170e+01, Rel_L2: 2.738e-01, L_inf: 2.738e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9700, Loss: 5.747e+00, Rel_L2: 2.645e-01, L_inf: 2.645e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9800, Loss: 8.477e+00, Rel_L2: 2.605e-01, L_inf: 2.605e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 9900, Loss: 3.812e+00, Rel_L2: 2.695e-01, L_inf: 2.695e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10000, Loss: 1.649e+00, Rel_L2: 2.547e-01, L_inf: 2.547e-01, t/iter: 2.5e-02\n",
      "\n",
      "Adjusting learning rate of group 0 to 8.1000e-04.\n",
      "Iter 10100, Loss: 1.789e-01, Rel_L2: 2.468e-01, L_inf: 2.468e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10200, Loss: 1.700e-01, Rel_L2: 2.428e-01, L_inf: 2.428e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10300, Loss: 5.616e-01, Rel_L2: 2.560e-01, L_inf: 2.560e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10400, Loss: 1.237e+01, Rel_L2: 2.483e-01, L_inf: 2.483e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10500, Loss: 1.953e+00, Rel_L2: 2.445e-01, L_inf: 2.445e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10600, Loss: 3.506e+00, Rel_L2: 2.463e-01, L_inf: 2.463e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10700, Loss: 1.353e+00, Rel_L2: 2.415e-01, L_inf: 2.415e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10800, Loss: 3.778e+01, Rel_L2: 2.611e-01, L_inf: 2.611e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 10900, Loss: 9.137e-01, Rel_L2: 2.479e-01, L_inf: 2.479e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11000, Loss: 7.428e+00, Rel_L2: 2.490e-01, L_inf: 2.490e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11100, Loss: 3.276e-01, Rel_L2: 2.373e-01, L_inf: 2.373e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11200, Loss: 3.809e+00, Rel_L2: 2.376e-01, L_inf: 2.376e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11300, Loss: 1.523e+01, Rel_L2: 2.426e-01, L_inf: 2.426e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11400, Loss: 2.222e+00, Rel_L2: 2.319e-01, L_inf: 2.319e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11500, Loss: 4.224e+00, Rel_L2: 2.412e-01, L_inf: 2.412e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11600, Loss: 1.452e+00, Rel_L2: 2.268e-01, L_inf: 2.268e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11700, Loss: 7.756e+00, Rel_L2: 2.360e-01, L_inf: 2.360e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11800, Loss: 1.898e+00, Rel_L2: 2.255e-01, L_inf: 2.255e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 11900, Loss: 6.174e-01, Rel_L2: 2.188e-01, L_inf: 2.188e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12000, Loss: 3.977e+00, Rel_L2: 2.288e-01, L_inf: 2.288e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12100, Loss: 1.665e+01, Rel_L2: 2.303e-01, L_inf: 2.303e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12200, Loss: 8.214e+00, Rel_L2: 2.211e-01, L_inf: 2.211e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12300, Loss: 1.783e-01, Rel_L2: 2.122e-01, L_inf: 2.122e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12400, Loss: 2.151e-01, Rel_L2: 2.103e-01, L_inf: 2.103e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12500, Loss: 1.049e+01, Rel_L2: 2.178e-01, L_inf: 2.178e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12600, Loss: 9.028e+00, Rel_L2: 2.122e-01, L_inf: 2.122e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12700, Loss: 3.845e+00, Rel_L2: 2.110e-01, L_inf: 2.110e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12800, Loss: 5.337e-01, Rel_L2: 2.160e-01, L_inf: 2.160e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 12900, Loss: 2.727e-01, Rel_L2: 2.048e-01, L_inf: 2.048e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13000, Loss: 1.783e+00, Rel_L2: 2.033e-01, L_inf: 2.033e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13100, Loss: 7.055e+00, Rel_L2: 2.056e-01, L_inf: 2.056e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13200, Loss: 1.137e+00, Rel_L2: 2.010e-01, L_inf: 2.010e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13300, Loss: 1.038e+01, Rel_L2: 2.059e-01, L_inf: 2.059e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13400, Loss: 2.217e+00, Rel_L2: 2.132e-01, L_inf: 2.132e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13500, Loss: 4.977e+00, Rel_L2: 1.990e-01, L_inf: 1.990e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13600, Loss: 1.045e+00, Rel_L2: 1.955e-01, L_inf: 1.955e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13700, Loss: 3.432e+00, Rel_L2: 1.948e-01, L_inf: 1.948e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13800, Loss: 6.255e-01, Rel_L2: 1.896e-01, L_inf: 1.896e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 13900, Loss: 1.677e+01, Rel_L2: 1.994e-01, L_inf: 1.994e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14000, Loss: 1.326e+00, Rel_L2: 1.897e-01, L_inf: 1.897e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14100, Loss: 4.428e+00, Rel_L2: 1.888e-01, L_inf: 1.888e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14200, Loss: 4.759e+00, Rel_L2: 1.897e-01, L_inf: 1.897e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14300, Loss: 5.764e-01, Rel_L2: 1.842e-01, L_inf: 1.842e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14400, Loss: 2.013e+00, Rel_L2: 1.817e-01, L_inf: 1.817e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14500, Loss: 3.246e+00, Rel_L2: 1.870e-01, L_inf: 1.870e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14600, Loss: 3.295e-01, Rel_L2: 1.822e-01, L_inf: 1.822e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14700, Loss: 5.438e+00, Rel_L2: 1.804e-01, L_inf: 1.804e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14800, Loss: 6.858e-01, Rel_L2: 1.817e-01, L_inf: 1.817e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 14900, Loss: 2.641e+00, Rel_L2: 1.887e-01, L_inf: 1.887e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 15000, Loss: 5.763e+00, Rel_L2: 1.820e-01, L_inf: 1.820e-01, t/iter: 2.5e-02\n",
      "\n",
      "Adjusting learning rate of group 0 to 7.2900e-04.\n",
      "Iter 15100, Loss: 1.081e-01, Rel_L2: 1.706e-01, L_inf: 1.706e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 15200, Loss: 1.025e-01, Rel_L2: 1.690e-01, L_inf: 1.690e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 15300, Loss: 5.507e-01, Rel_L2: 1.679e-01, L_inf: 1.679e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 15400, Loss: 1.128e-01, Rel_L2: 1.693e-01, L_inf: 1.693e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 15500, Loss: 1.124e+01, Rel_L2: 1.720e-01, L_inf: 1.720e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 15600, Loss: 1.410e+01, Rel_L2: 1.826e-01, L_inf: 1.826e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 15700, Loss: 5.871e-01, Rel_L2: 1.684e-01, L_inf: 1.684e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 15800, Loss: 1.460e-01, Rel_L2: 1.651e-01, L_inf: 1.651e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 15900, Loss: 2.809e+00, Rel_L2: 1.699e-01, L_inf: 1.699e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16000, Loss: 1.877e+00, Rel_L2: 1.670e-01, L_inf: 1.670e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16100, Loss: 1.829e+00, Rel_L2: 1.690e-01, L_inf: 1.690e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16200, Loss: 5.856e-01, Rel_L2: 1.638e-01, L_inf: 1.638e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16300, Loss: 1.147e+00, Rel_L2: 1.601e-01, L_inf: 1.601e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16400, Loss: 2.308e+00, Rel_L2: 1.597e-01, L_inf: 1.597e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16500, Loss: 2.751e+00, Rel_L2: 1.598e-01, L_inf: 1.598e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16600, Loss: 6.862e-01, Rel_L2: 1.587e-01, L_inf: 1.587e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16700, Loss: 1.760e+00, Rel_L2: 1.562e-01, L_inf: 1.562e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16800, Loss: 1.780e+00, Rel_L2: 1.552e-01, L_inf: 1.552e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 16900, Loss: 1.216e+00, Rel_L2: 1.533e-01, L_inf: 1.533e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17000, Loss: 2.412e-01, Rel_L2: 1.497e-01, L_inf: 1.497e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17100, Loss: 9.555e+00, Rel_L2: 1.658e-01, L_inf: 1.658e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17200, Loss: 2.104e+00, Rel_L2: 1.517e-01, L_inf: 1.517e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17300, Loss: 2.066e+00, Rel_L2: 1.475e-01, L_inf: 1.475e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17400, Loss: 5.530e-01, Rel_L2: 1.453e-01, L_inf: 1.453e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17500, Loss: 6.600e+00, Rel_L2: 1.471e-01, L_inf: 1.471e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17600, Loss: 5.366e-01, Rel_L2: 1.426e-01, L_inf: 1.426e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17700, Loss: 8.711e+00, Rel_L2: 1.491e-01, L_inf: 1.491e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17800, Loss: 4.902e-01, Rel_L2: 1.413e-01, L_inf: 1.413e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 17900, Loss: 2.882e-01, Rel_L2: 1.396e-01, L_inf: 1.396e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18000, Loss: 8.621e-01, Rel_L2: 1.407e-01, L_inf: 1.407e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18100, Loss: 1.039e-01, Rel_L2: 1.370e-01, L_inf: 1.370e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18200, Loss: 5.392e-01, Rel_L2: 1.363e-01, L_inf: 1.363e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18300, Loss: 4.717e-01, Rel_L2: 1.350e-01, L_inf: 1.350e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18400, Loss: 1.141e+01, Rel_L2: 1.428e-01, L_inf: 1.428e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18500, Loss: 5.898e-01, Rel_L2: 1.319e-01, L_inf: 1.319e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18600, Loss: 6.411e-01, Rel_L2: 1.305e-01, L_inf: 1.305e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18700, Loss: 3.164e-01, Rel_L2: 1.297e-01, L_inf: 1.297e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18800, Loss: 1.088e+00, Rel_L2: 1.306e-01, L_inf: 1.306e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 18900, Loss: 1.659e+00, Rel_L2: 1.290e-01, L_inf: 1.290e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19000, Loss: 2.383e-01, Rel_L2: 1.325e-01, L_inf: 1.325e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19100, Loss: 6.351e-01, Rel_L2: 1.238e-01, L_inf: 1.238e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19200, Loss: 1.326e+00, Rel_L2: 1.238e-01, L_inf: 1.238e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19300, Loss: 1.550e-01, Rel_L2: 1.209e-01, L_inf: 1.209e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19400, Loss: 2.364e-01, Rel_L2: 1.207e-01, L_inf: 1.207e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19500, Loss: 1.566e+00, Rel_L2: 1.253e-01, L_inf: 1.253e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19600, Loss: 3.002e-01, Rel_L2: 1.182e-01, L_inf: 1.182e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19700, Loss: 3.165e-01, Rel_L2: 1.167e-01, L_inf: 1.167e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19800, Loss: 1.479e-01, Rel_L2: 1.146e-01, L_inf: 1.146e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 19900, Loss: 1.389e+01, Rel_L2: 1.301e-01, L_inf: 1.301e-01, t/iter: 2.5e-02\n",
      "\n",
      "Iter 20000, Loss: 5.243e-01, Rel_L2: 1.176e-01, L_inf: 1.176e-01, t/iter: 2.5e-02\n",
      "\n",
      "Adjusting learning rate of group 0 to 6.5610e-04.\n",
      "LBFGS switch\n",
      "Iter 20100, Loss: 5.530e-02, Rel_L2: 1.073e-01, L_inf: 1.073e-01, t/iter: 7.2e-02\n",
      "\n",
      "Iter 20200, Loss: 4.340e-02, Rel_L2: 1.013e-01, L_inf: 1.013e-01, t/iter: 7.2e-02\n",
      "\n",
      "Iter 20300, Loss: 3.331e-02, Rel_L2: 9.767e-02, L_inf: 9.767e-02, t/iter: 7.2e-02\n",
      "\n",
      "Iter 20400, Loss: 2.604e-02, Rel_L2: 8.355e-02, L_inf: 8.355e-02, t/iter: 7.2e-02\n",
      "\n",
      "Iter 20500, Loss: 2.066e-02, Rel_L2: 6.747e-02, L_inf: 6.747e-02, t/iter: 7.2e-02\n",
      "\n",
      "Iter 20600, Loss: 1.668e-02, Rel_L2: 5.603e-02, L_inf: 5.603e-02, t/iter: 7.2e-02\n",
      "\n",
      "Iter 20700, Loss: 1.343e-02, Rel_L2: 4.964e-02, L_inf: 4.964e-02, t/iter: 7.2e-02\n",
      "\n",
      "Iter 20800, Loss: 1.107e-02, Rel_L2: 4.445e-02, L_inf: 4.445e-02, t/iter: 7.2e-02\n",
      "\n",
      "Iter 20900, Loss: 9.207e-03, Rel_L2: 4.061e-02, L_inf: 4.061e-02, t/iter: 7.2e-02\n",
      "\n",
      "Iter 21000, Loss: 8.059e-03, Rel_L2: 3.796e-02, L_inf: 3.796e-02, t/iter: 7.2e-02\n",
      "\n",
      "Iter 21100, Loss: 7.050e-03, Rel_L2: 3.632e-02, L_inf: 3.632e-02, t/iter: 7.2e-02\n",
      "\n",
      "Iter 21200, Loss: 6.364e-03, Rel_L2: 3.471e-02, L_inf: 3.471e-02, t/iter: 7.2e-02\n",
      "\n",
      "Iter 21300, Loss: 5.711e-03, Rel_L2: 3.443e-02, L_inf: 3.443e-02, t/iter: 7.2e-02\n",
      "\n",
      "Iter 21400, Loss: 5.074e-03, Rel_L2: 3.410e-02, L_inf: 3.410e-02, t/iter: 7.2e-02\n",
      "\n",
      "Iter 21500, Loss: 4.520e-03, Rel_L2: 3.258e-02, L_inf: 3.258e-02, t/iter: 7.2e-02\n",
      "\n",
      "Iter 21600, Loss: 4.131e-03, Rel_L2: 3.243e-02, L_inf: 3.243e-02, t/iter: 7.2e-02\n",
      "\n",
      "Iter 21700, Loss: 3.683e-03, Rel_L2: 3.159e-02, L_inf: 3.159e-02, t/iter: 7.2e-02\n",
      "\n",
      "Iter 21800, Loss: 3.301e-03, Rel_L2: 2.966e-02, L_inf: 2.966e-02, t/iter: 7.2e-02\n",
      "\n",
      "Iter 21900, Loss: 2.957e-03, Rel_L2: 2.800e-02, L_inf: 2.800e-02, t/iter: 7.2e-02\n",
      "\n",
      "Iter 22000, Loss: 2.639e-03, Rel_L2: 2.613e-02, L_inf: 2.613e-02, t/iter: 7.2e-02\n",
      "\n",
      "CPU times: user 9min 31s, sys: 2.56 s, total: 9min 33s\n",
      "Wall time: 9min 39s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "model.train() # Vanilla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 470
    },
    "executionInfo": {
     "elapsed": 4967,
     "status": "ok",
     "timestamp": 1685110007390,
     "user": {
      "displayName": "Sokratis An",
      "userId": "06375667078137359429"
     },
     "user_tz": -120
    },
    "id": "WyzJiQJS5oE1",
    "outputId": "2fc4e87f-449f-48fc-8860-ba6512704707"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L2: 0.003411080459538149\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Prediction\n",
    "Exact = Exact0\n",
    "X, T = np.meshgrid(x0, t0)\n",
    "X_star = np.hstack((X.flatten()[:,None], T.flatten()[:,None]))\n",
    "u_pred = model.predict(X_star)\n",
    "U_pred = np.reshape(u_pred, (Exact.shape[1], Exact.shape[0])).T\n",
    "l2_rel = np.linalg.norm(Exact.flatten() - U_pred.flatten(), 2) / np.linalg.norm(Exact.flatten(), 2)\n",
    "print('L2:', l2_rel)\n",
    "\n",
    "plt.figure(1)\n",
    "plt.title('Abs Error u')\n",
    "plt.xlabel('y')\n",
    "plt.ylabel('x') \n",
    "plt.imshow(np.abs(Exact-U_pred), aspect='auto', cmap='rainbow')\n",
    "plt.colorbar()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "gpuType": "T4",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "firstEnv",
   "language": "python",
   "name": "firstenv"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
